home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #4 / Amiga Plus CD - 2000 - No. 4.iso / Tools / Treiber / Misc / Mroocheck / FreeWheel / Source / CxCustom.c < prev    next >
C/C++ Source or Header  |  2000-04-20  |  10KB  |  372 lines
  1.  
  2. #include <exec/types.h>
  3. #include <devices/inputevent.h>
  4. #include <libraries/commodities.h>
  5. #include <intuition/newmouse.h>
  6. #include <intuition/intuitionbase.h>
  7. #include <intuition/screens.h>
  8. #include <graphics/clip.h>
  9. #include <graphics/layers.h>
  10.  
  11. #include <clib/exec_protos.h>
  12. #include <clib/commodities_protos.h>
  13. #include <clib/alib_protos.h>
  14.  
  15. #include "WheelMouse.h"
  16. #include "Scroll.h"
  17. #include "Cx.h"
  18. #include "RawKey.h"
  19.  
  20. #include "CxCustom.h"
  21.  
  22. extern struct IntuitionBase *IntuitionBase;
  23. extern struct WheelMouseContext *MyWM;
  24. extern struct CxContext *Cx;
  25.  
  26. int AddIntAtomic(int *a,int v);
  27.  
  28. void HandleDoubleClick(struct ButtonData *bd,struct InputEvent *ie);
  29. void HandleClickToFront(struct InputEvent *ie);
  30. BOOL InWindowBorder(struct Window *win);
  31.  
  32.  
  33. void CxDepthArrange(int dy)
  34. {
  35.   struct Window *win;
  36.   if(win=WindowUnderPointer())
  37.   {
  38.     if(win->Flags&WFLG_DEPTHGADGET)
  39.     {
  40.       if(dy<0)
  41.         WindowToBack(win);
  42.       else
  43.         WindowToFront(win);
  44.     }
  45.   }
  46. }
  47.  
  48.  
  49. void CxCustomRoutine(CxMsg *msg,CxObj *obj)
  50. {
  51.   static int xrem=0,yrem=0;
  52.   static int scrxrem=0,scryrem=0;
  53.   int x,y,dx,dy,msx,msy,fdx,fdy;
  54.   BOOL send=FALSE;
  55.   struct InputEvent *e=CxMsgData(msg);
  56.  
  57.   msx=MyWM->MouseSpeedX;
  58.   msy=MyWM->MouseSpeedY;
  59.  
  60.   dx=dy=fdx=fdy=0;
  61.  
  62.   if(((MyWM->MidButton.State)&&(MyWM->MidButton.ClickMode==ClickShiftClick))
  63.    ||((MyWM->FourthButton.State)&&(MyWM->FourthButton.ClickMode==ClickShiftClick)))
  64.   {
  65.     e->ie_Qualifier&=~IEQUALIFIER_MIDBUTTON;
  66.     e->ie_Qualifier|=IEQUALIFIER_LEFTBUTTON|IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT;
  67.   }
  68.  
  69.   switch(e->ie_Class)
  70.   {
  71.     case IECLASS_RAWMOUSE:
  72.       x=e->ie_X; y=e->ie_Y;
  73.       if(msx>100)
  74.         if(x<3 && x>-3)
  75.           msx=100;
  76.       if(msy>100)
  77.         if(y<3 && y>-3)
  78.           msy=100;
  79.       x=e->ie_X*msx+xrem; xrem=x; x/=100; xrem-=x*100; e->ie_X=x;
  80.       y=e->ie_Y*msy+yrem; yrem=y; y/=100; yrem-=y*100; e->ie_Y=y;
  81.  
  82.       switch(e->ie_Code)
  83.       {
  84.         case IECODE_MBUTTON:
  85.           HandleDoubleClick(&MyWM->MidButton,e);
  86.  
  87.           MyWM->MidButton.State=TRUE;
  88.           switch(MyWM->MidButton.ClickMode)
  89.           {
  90.             case ClickShift:
  91.               e->ie_Code=RK_LShift;
  92.               e->ie_Class=IECLASS_RAWKEY;
  93.               break;
  94.             case ClickShiftClick:
  95.               e->ie_Code=IECODE_LBUTTON;
  96.               e->ie_Qualifier=IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT;
  97.               break;
  98.             case ClickCycleScreens:
  99.               ScreenToBack(IntuitionBase->FirstScreen);
  100.               break;
  101.             case ClickMoveScrollToggle:
  102.               MyWM->MidButton.ScrollToggle^=1;
  103.               break;
  104.             case ClickMoveToScroll:
  105.               MyWM->MidButton.ScrollToggle=1;
  106.               break;
  107.             case ClickToggleLMB:
  108.               if(MyWM->MidButton.LMBToggle)
  109.               {
  110.                 e->ie_Code=IECODE_LBUTTON|IECODE_UP_PREFIX;
  111.                 MyWM->MidButton.LMBToggle=0;
  112.               }
  113.               else
  114.               {
  115.                 e->ie_Code=IECODE_LBUTTON;
  116.                 MyWM->MidButton.LMBToggle=1;
  117.               }
  118.               break;
  119.           }
  120.           break; /* IECODE_MBUTTON */
  121.  
  122.         case IECODE_MBUTTON|IECODE_UP_PREFIX:
  123.  
  124.           MyWM->MidButton.State=FALSE;
  125.           switch(MyWM->MidButton.ClickMode)
  126.           {
  127.             case ClickShift:
  128.               e->ie_Class=IECLASS_RAWKEY;
  129.               e->ie_Code=RK_LShift|IECODE_UP_PREFIX;
  130.               break;
  131.             case ClickShiftClick:
  132.               e->ie_Code=IECODE_UP_PREFIX|IECODE_LBUTTON;
  133.               e->ie_Qualifier=IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT;
  134.               break;
  135.             case ClickMoveToScroll:
  136.               MyWM->MidButton.ScrollToggle=0;
  137.               break;
  138.           }
  139.           break; /* IECODE_MBUTTON|IECODE_UP_PREFIX */
  140.  
  141.         case IECODE_LBUTTON:
  142.           if(MyWM->ClickToFront||MyWM->ClickToBack)
  143.             HandleClickToFront(e);
  144.           break;
  145.  
  146.         case IECODE_LBUTTON|IECODE_UP_PREFIX:
  147.             MyWM->MidButton.LMBToggle=0;
  148.             MyWM->FourthButton.LMBToggle=0;
  149.           break;
  150.       }
  151.  
  152.  
  153.       /* Generate scrolling movement from mouse movement:
  154.          A remainder is maintained, so small movements will accumulate. */
  155.  
  156.       if((MyWM->MidButton.ScrollToggle)||(MyWM->FourthButton.ScrollToggle))
  157.       {
  158.         fdx=e->ie_X*MyWM->FakeScrollSpeed+scrxrem;
  159.         scrxrem=fdx; fdx/=256; scrxrem-=fdx*256; e->ie_X=0;
  160.         fdy=e->ie_Y*MyWM->FakeScrollSpeed+scryrem;
  161.         scryrem=fdy; fdy/=256; scryrem-=fdy*256; e->ie_Y=0;
  162.         AddIntAtomic(&MyWM->FakeY,fdy);
  163.         AddIntAtomic(&MyWM->FakeX,fdx);
  164.         Signal(MyWM->MainTask,MyWM->Signals);
  165.       }
  166.  
  167.       break; /* IECLASS_RAWMOUSE */
  168.  
  169.     case IECLASS_RAWKEY:
  170.       switch(e->ie_Code)
  171.       {
  172.         case NM_BUTTON_FOURTH:
  173.           HandleDoubleClick(&MyWM->MidButton,e);
  174.  
  175.           MyWM->FourthButton.State=TRUE;
  176.           switch(MyWM->FourthButton.ClickMode)
  177.           {
  178.             case ClickShift:
  179.               e->ie_Code=RK_LShift;
  180.               e->ie_Class=IECLASS_RAWKEY;
  181.               break;
  182.             case ClickShiftClick:
  183.               e->ie_Class=IECLASS_RAWMOUSE;
  184.               e->ie_Code=IECODE_LBUTTON;
  185.               e->ie_Qualifier=IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT;
  186.               break;
  187.             case ClickCycleScreens:
  188.               ScreenToBack(IntuitionBase->FirstScreen);
  189.               break;
  190.             case ClickMoveScrollToggle:
  191.               MyWM->FourthButton.ScrollToggle^=1;
  192.               break;
  193.             case ClickMoveToScroll:
  194.               MyWM->FourthButton.ScrollToggle=1;
  195.               break;
  196.             case ClickToggleLMB:
  197.               if(MyWM->FourthButton.LMBToggle)
  198.               {
  199.                 e->ie_Class=IECLASS_RAWMOUSE;
  200.                 e->ie_Code=IECODE_LBUTTON|IECODE_UP_PREFIX;
  201.                 e->ie_X=e->ie_Y=0;
  202.                 MyWM->FourthButton.LMBToggle=0;
  203.               }
  204.               else
  205.               {
  206.                 e->ie_Class=IECLASS_RAWMOUSE;
  207.                 e->ie_Code=IECODE_LBUTTON;
  208.                 e->ie_X=e->ie_Y=0;
  209.                 MyWM->FourthButton.LMBToggle=1;
  210.               }
  211.               break;
  212.           }
  213.           break;
  214.         case NM_BUTTON_FOURTH|IECODE_UP_PREFIX:
  215.           MyWM->FourthButton.State=FALSE;
  216.           switch(MyWM->FourthButton.ClickMode)
  217.           {
  218.             case ClickShift:
  219.               e->ie_Class=IECLASS_RAWKEY;
  220.               e->ie_Code=RK_LShift|IECODE_UP_PREFIX;
  221.               break;
  222.             case ClickShiftClick:
  223.               e->ie_Class=IECLASS_RAWMOUSE;
  224.               e->ie_Code=IECODE_UP_PREFIX|IECODE_LBUTTON;
  225.               e->ie_Qualifier=IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT;
  226.               break;
  227.             case ClickMoveToScroll:
  228.               MyWM->FourthButton.ScrollToggle=0;
  229.               break;
  230.           }
  231.           break;
  232.         case NM_WHEEL_UP:
  233.           dy=-1;
  234.           break;
  235.         case NM_WHEEL_DOWN:
  236.           dy=1;
  237.           break;
  238.         case NM_WHEEL_LEFT:
  239.           dx=-1;
  240.           break;
  241.         case NM_WHEEL_RIGHT:
  242.           dx=1;
  243.           break;
  244.       }
  245.       break; /* IECLASS_RAWKEY */
  246.   }
  247.  
  248.   if(dx||dy)
  249.   {
  250.     if(dy&&(MyWM->MidButton.State)&&(MyWM->MidButton.ClickRollMode==ClickRollDepthArrange))
  251.     {
  252.       CxDepthArrange(dy);
  253.       MyWM->MidButton.State=FALSE;
  254.     }
  255.     else if(dy&&(MyWM->FourthButton.State)&&(MyWM->FourthButton.ClickRollMode==ClickRollDepthArrange))
  256.     {
  257.       CxDepthArrange(dy);
  258.       MyWM->FourthButton.State=FALSE;
  259.     }
  260.     else
  261.     {
  262.       if(dy&&(MyWM->MidButton.State)&&(MyWM->MidButton.ClickRollMode==ClickRollHorizontalScroll))
  263.       {
  264.         dx=dy; dy=0;
  265.       }
  266.       else if(dy&&(MyWM->FourthButton.State)&&(MyWM->FourthButton.ClickRollMode==ClickRollHorizontalScroll))
  267.       {
  268.         dx=dy; dy=0;
  269.       }
  270.       if((MyWM->MidButton.AxisToggle)||(MyWM->FourthButton.AxisToggle))
  271.       {
  272.         dx=dy; dy=0;
  273.       }
  274.       /* As long as this addition is atomic, it is safe for the main
  275.          task to read the variables and this task to write them,
  276.          without semaphore protection.  The main task will read the
  277.          value, and then subtract the value it has just read (again
  278.          with an atomic operation). */
  279. /*      dx+=fdx; dy+=fdy;*/
  280.       AddIntAtomic(&MyWM->ScrollY,dy);
  281.       AddIntAtomic(&MyWM->ScrollX,dx);
  282.       Signal(MyWM->MainTask,MyWM->Signals);
  283.     }
  284.   }
  285.  
  286.   if((MyWM->MidButton.ClickMode==ClickShift)&&(MyWM->MidButton.State))
  287.   {
  288.     e->ie_Qualifier|=IEQUALIFIER_LSHIFT;
  289.     e->ie_Qualifier&=~IEQUALIFIER_MIDBUTTON;
  290.   }
  291.  
  292.   if((MyWM->FourthButton.ClickMode==ClickShift)&&(MyWM->FourthButton.State))
  293.     e->ie_Qualifier|=IEQUALIFIER_LSHIFT;
  294. }
  295.  
  296.  
  297. void HandleDoubleClick(struct ButtonData *bd,struct InputEvent *ie)
  298. {
  299.   if((bd->Count==1) && (DoubleClick(bd->Secs,bd->Microsecs,ie->ie_TimeStamp.tv_secs,ie->ie_TimeStamp.tv_micro)))
  300.   {
  301.     switch(bd->DoubleClickMode)
  302.     {
  303.       case DClickCycleScreens:
  304.         ScreenToBack(IntuitionBase->FirstScreen);
  305.         break;
  306.       case DClickSwapAxis:
  307.         bd->AxisToggle^=1;
  308.         break;
  309.     }
  310.     bd->Count=0;
  311.   }
  312.   else
  313.   {
  314.     bd->Count=1;
  315.     bd->Secs=ie->ie_TimeStamp.tv_secs;
  316.     bd->Microsecs=ie->ie_TimeStamp.tv_micro;
  317.   }
  318. }
  319.  
  320.  
  321. void HandleClickToFront(struct InputEvent *ie)
  322. {
  323.   static struct Window *win=0,*lastwin=0;
  324.   static long secs=0,microsecs=0,count=0;
  325.  
  326.   win=WindowUnderPointer();
  327.   if(InWindowBorder(win))
  328.   {
  329.     if((count==1) && (win==lastwin) && (DoubleClick(secs,microsecs,ie->ie_TimeStamp.tv_secs,ie->ie_TimeStamp.tv_micro)))
  330.     {
  331.       struct Window *topwin=NULL;
  332.       if(win->WScreen->LayerInfo.top_layer)
  333.         topwin=win->WScreen->LayerInfo.top_layer->Window;
  334.       if((win==topwin)&&(MyWM->ClickToBack))
  335.         WindowToBack(win);
  336.       else
  337.         WindowToFront(win);
  338.       count=0;
  339.     }
  340.     else
  341.     {
  342.       count=1; lastwin=win;
  343.       secs=ie->ie_TimeStamp.tv_secs;
  344.       microsecs=ie->ie_TimeStamp.tv_micro;
  345.     }
  346.   }
  347. }
  348.  
  349.  
  350. BOOL InWindowBorder(struct Window *win)
  351. {
  352.   int x,y;
  353.   if(!win)
  354.     return(FALSE);
  355.   x=win->MouseX; y=win->MouseY;
  356.   if((win->Flags&WFLG_BORDERLESS)&&!(win->Flags&WFLG_BACKDROP))
  357.   {
  358.     if((x>0)&&(y>0)&&(x<win->Width)&&(y<win->Height))
  359.       return(TRUE);
  360.   }
  361.   if(x<win->BorderLeft)
  362.     return(TRUE);
  363.   if(y<win->BorderTop)
  364.     return(TRUE);
  365.   if(x>(win->Width-win->BorderRight-1))
  366.     return(TRUE);
  367.   if(y>(win->Height-win->BorderBottom-1))
  368.     return(TRUE);
  369.   return(FALSE);
  370. }
  371.  
  372.